components/scrapecreators/sources/new-profile-update/test-event.mjs (1)

48-49: Consider normalizing collection fields

tags is a comma-separated string. Prefer an array (e.g., ["Channel", "Channel Name", "Channel Description"]) to avoid downstream splitting and i18n issues.

components/scrapecreators/common/utils.mjs (1)

1-46: Harden deep-diff: handle arrays/non‑plain objects and avoid false negatives

Current recursion treats any object as nested. Non‑plain objects like Date, RegExp, Map, Set, and arrays can produce incorrect diffs (e.g., two different Dates appear unchanged). Also, there’s no cycle protection.

Refactor to:

• Recurse only into plain objects.
• Compare arrays element‑wise (or treat as modified if length/ordering differences are unacceptable).
• Treat non‑plain objects as value types (strict equality or .valueOf() for Date).
• Add a visited set to prevent infinite recursion.

Patch sketch:

-export function getObjectDiff(obj1, obj2) {
-  const diff = {};
+export function getObjectDiff(obj1, obj2, _seen = new WeakSet()) {
+  const diff = {};
+  const isPlainObject = (v) => v && typeof v === "object" && v.constructor === Object;
+  const isArray = Array.isArray;
+  const isNonPlainObject = (v) =>
+    v && typeof v === "object" && !isPlainObject(v) && !isArray(v);
+
+  // Cycle guard
+  if (obj1 && typeof obj1 === "object") {
+    if (_seen.has(obj1)) return diff;
+    _seen.add(obj1);
+  }

   // Check for differences in obj1's properties
-  for (const key in obj1) {
-    if (Object.prototype.hasOwnProperty.call(obj1, key)) {
+  for (const key of Object.keys(obj1 ?? {})) {
+    if (Object.prototype.hasOwnProperty.call(obj1, key)) {
       if (!Object.prototype.hasOwnProperty.call(obj2, key)) {
         diff[key] = {
           oldValue: obj1[key],
           newValue: undefined,
           status: "deleted",
         };
-      } else if (typeof obj1[key] === "object" && obj1[key] !== null &&
-                 typeof obj2[key] === "object" && obj2[key] !== null) {
-        const nestedDiff = getObjectDiff(obj1[key], obj2[key]);
+      } else if (isArray(obj1[key]) && isArray(obj2[key])) {
+        // Array diff: element-wise
+        const a1 = obj1[key], a2 = obj2[key];
+        const max = Math.max(a1.length, a2.length);
+        const arrDiff = {};
+        for (let i = 0; i < max; i++) {
+          if (i in a1 && !(i in a2)) {
+            arrDiff[i] = { oldValue: a1[i], newValue: undefined, status: "deleted" };
+          } else if (!(i in a1) && i in a2) {
+            arrDiff[i] = { oldValue: undefined, newValue: a2[i], status: "added" };
+          } else if (i in a1 && i in a2) {
+            if (isPlainObject(a1[i]) && isPlainObject(a2[i])) {
+              const nd = getObjectDiff(a1[i], a2[i], _seen);
+              if (Object.keys(nd).length) arrDiff[i] = { status: "modified", changes: nd };
+            } else if (a1[i] !== a2[i]) {
+              arrDiff[i] = { oldValue: a1[i], newValue: a2[i], status: "modified" };
+            }
+          }
+        }
+        if (Object.keys(arrDiff).length) {
+          diff[key] = { status: "modified", changes: arrDiff };
+        }
+      } else if (isPlainObject(obj1[key]) && isPlainObject(obj2[key])) {
+        const nestedDiff = getObjectDiff(obj1[key], obj2[key], _seen);
         if (Object.keys(nestedDiff).length > 0) {
           diff[key] = {
             status: "modified",
             changes: nestedDiff,
           };
         }
+      } else if (isNonPlainObject(obj1[key]) || isNonPlainObject(obj2[key])) {
+        // Compare non-plain objects as values (e.g., Date.valueOf())
+        const v1 = obj1[key] instanceof Date ? obj1[key].valueOf() : obj1[key];
+        const v2 = obj2[key] instanceof Date ? obj2[key].valueOf() : obj2[key];
+        if (v1 !== v2) {
+          diff[key] = { oldValue: obj1[key], newValue: obj2[key], status: "modified" };
+        }
       } else if (obj1[key] !== obj2[key]) {
         diff[key] = {
           oldValue: obj1[key],
           newValue: obj2[key],
           status: "modified",
         };
       }
     }
   }

   // Check for properties added in obj2
-  for (const key in obj2) {
-    if (Object.prototype.hasOwnProperty.call(obj2, key)) {
+  for (const key of Object.keys(obj2 ?? {})) {
+    if (Object.prototype.hasOwnProperty.call(obj2, key)) {
       if (!Object.prototype.hasOwnProperty.call(obj1, key)) {
         diff[key] = {
           oldValue: undefined,
           newValue: obj2[key],
           status: "added",
         };
       }
     }
   }

   return diff;
 }

Please confirm if profile snapshots can contain Dates, Maps/Sets, or specialized objects. If strictly JSON (primitives/arrays/plain objects), we can simplify the array handling and skip non‑plain types.

components/scrapecreators/common/constants.mjs (1)

1-43: Stabilize and future‑proof platform lists

• Dedupe PLATFORMS to avoid duplicates as groups evolve.
• Freeze exports to prevent accidental mutation at runtime.
• Optional: rename "user/boards" to userBoards to avoid slash‑key edge cases.

Example:

-export const PATH_PLATFORMS = {
+export const PATH_PLATFORMS = Object.freeze({
-  "user/boards": [
+  // Consider: userBoards
+  "user/boards": [
     "pinterest",
   ],
   ...
-};
+});
 
-export const URL_PLATFORMS = [
+export const URL_PLATFORMS = Object.freeze([
   "linkedin",
   "facebook",
   ...PATH_PLATFORMS["empty"],
-];
+]);
 
-export const SEARCH_PLATFORMS = [
+export const SEARCH_PLATFORMS = Object.freeze([
   "tiktok",
   "threads",
-];
+]);
 
-export const HANDLE_PLATFORMS = [
+export const HANDLE_PLATFORMS = Object.freeze([
   "instagram",
   "twitter",
   "truthsocial",
   "bluesky",
   "twitch",
   "snapchat",
   ...SEARCH_PLATFORMS,
   ...PATH_PLATFORMS["user/boards"],
   ...PATH_PLATFORMS["channel"],
-];
+]);
 
-export const PLATFORMS = [
-  ...URL_PLATFORMS,
-  ...HANDLE_PLATFORMS,
-];
+export const PLATFORMS = Object.freeze(
+  Array.from(new Set([
+    ...URL_PLATFORMS,
+    ...HANDLE_PLATFORMS,
+  ]))
+);

components/scrapecreators/sources/common/base.mjs (1)

41-47: Use Date.now() and emit string ids

Minor polish:

• Date.parse(new Date()) is wasteful; use Date.now().
• Normalize event id to string to avoid numeric id collisions across sources.

-        this.$emit(item, {
-          id: item[fieldId],
-          summary: this.getSummary(item),
-          ts: Date.parse(new Date()),
-        });
+        this.$emit(item, {
+          id: String(item[fieldId]),
+          summary: this.getSummary(item),
+          ts: Date.now(),
+        });

components/scrapecreators/actions/search-creators/search-creators.mjs (2)

12-18: Avoid diverging platform options here (potential mismatch with app-level PLATFORMS).

This action overrides the app’s platform propDefinition options with SEARCH_PLATFORMS (currently ["tiktok","threads"]). That may exclude platforms users expect (e.g., YouTube/Instagram per issue), or fall out of sync with app-level PLATFORMS.

Option A: Remove the options override and rely on app’s PLATFORMS.

   platform: {
     propDefinition: [
       app,
       "platform",
     ],
-    options: SEARCH_PLATFORMS,
   },

Option B: If search truly supports a subset, update SEARCH_PLATFORMS in common/constants.mjs to the intended, documented set and add a short note in the action’s description clarifying supported platforms. Based on PR objectives.

---

47-48: More helpful summary (include platform and count).

Small UX win: show platform and number of results.

-    $.export("$summary", `Successfully searched for **${this.query}**`);
+    $.export("$summary", `Found ${data.length} creator(s) on ${this.platform} for "${this.query}"`);

components/scrapecreators/actions/fetch-creator-profile/fetch-creator-profile.mjs (1)

25-35: Tighten the summary.

Include platform to aid debugging across multi-platform workflows.

-    const summary = `Successfully fetched creator profile for **${this.profileId}**`;
+    const summary = `Fetched ${this.platform} profile: ${this.profileId}`;

components/scrapecreators/sources/new-profile-update/new-profile-update.mjs (1)

59-62: Use Date.now() directly for timestamps.

Date.parse(new Date()) is equivalent but noisier. Prefer Date.now().

-          ts: Date.parse(new Date()),
+          ts: Date.now(),

components/scrapecreators/scrapecreators.app.mjs (2)

71-84: Simplify parsePath predicate (return boolean).

Current .find() returns a truthy string (key) as the predicate result. Works, but non-idiomatic. Return a boolean for clarity.

-    parsePath(platform) {
-      const path = Object.entries(PATH_PLATFORMS).find(([
-        key,
-        value,
-      ]) => value.includes(platform)
-        ? key
-        : null);
-
-      return path
-        ? path[0] === "empty"
-          ? ""
-          : `/${path[0]}`
-        : "/profile";
-    },
+    parsePath(platform) {
+      const entry = Object.entries(PATH_PLATFORMS)
+        .find(([, value]) => value.includes(platform));
+      return entry
+        ? (entry[0] === "empty" ? "" : `/${entry[0]}`)
+        : "/profile";
+    },

---

86-113: Do not mutate the caller’s params in paginate; add a default for users.

Avoid side effects across iterations/callers and guard against missing arrays.

-    async *paginate({
-      fn, params = {}, platform, maxResults = null, ...opts
-    }) {
-      let hasMore = false;
-      let count = 0;
-      let newCursor;
-
-      do {
-        params.cursor = newCursor;
-        const {
-          cursor,
-          users,
-        } = await fn({
-          platform,
-          params,
-          ...opts,
-        });
+    async *paginate({ fn, params = {}, platform, maxResults = null, ...opts }) {
+      let hasMore = false;
+      let count = 0;
+      let newCursor;
+      const baseParams = { ...params };
+
+      do {
+        const reqParams = { ...baseParams, cursor: newCursor };
+        const { cursor, users = [] } = await fn({
+          platform,
+          params: reqParams,
+          ...opts,
+        });
         for (const d of users) {
           yield d;
 
           if (maxResults && ++count === maxResults) {
             return count;
           }
         }
 
         newCursor = cursor;
-        hasMore = users.length;
+        hasMore = users.length;
 
       } while (hasMore);
     },

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: jcortes
PR: PipedreamHQ/pipedream#14935
File: components/sailpoint/package.json:15-18
Timestamp: 2024-12-12T19:23:09.039Z
Learning: When developing Pipedream components, do not add built-in Node.js modules like `fs` to `package.json` dependencies, as they are native modules provided by the Node.js runtime.